const express = require('express');
const multer = require('multer');
const path = require('path');
const fs = require('fs');
const { body, validationResult } = require('express-validator');
const logger = require('../utils/logger');

const router = express.Router();

// 确保上传目录存在
const uploadDir = path.join(__dirname, '../uploads');
const imageDir = path.join(uploadDir, 'images');
const documentDir = path.join(uploadDir, 'documents');

[uploadDir, imageDir, documentDir].forEach(dir => {
  if (!fs.existsSync(dir)) {
    fs.mkdirSync(dir, { recursive: true });
  }
});

// 文件过滤器
const fileFilter = (req, file, cb) => {
  // 允许的图片类型
  const allowedImageTypes = /jpeg|jpg|png|gif|webp/;
  // 允许的文档类型
  const allowedDocTypes = /pdf|doc|docx|txt|md/;
  
  const extname = allowedImageTypes.test(path.extname(file.originalname).toLowerCase()) ||
                  allowedDocTypes.test(path.extname(file.originalname).toLowerCase());
  const mimetype = /image\/(jpeg|jpg|png|gif|webp)|application\/(pdf|msword|vnd\.openxmlformats-officedocument\.wordprocessingml\.document)|text\/(plain|markdown)/.test(file.mimetype);

  if (mimetype && extname) {
    return cb(null, true);
  } else {
    cb(new Error('不支持的文件类型'));
  }
};

// 存储配置
const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    // 根据文件类型选择存储目录
    if (file.mimetype.startsWith('image/')) {
      cb(null, imageDir);
    } else {
      cb(null, documentDir);
    }
  },
  filename: (req, file, cb) => {
    // 生成唯一文件名：时间戳 + 随机数 + 原始扩展名
    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
    const ext = path.extname(file.originalname);
    cb(null, file.fieldname + '-' + uniqueSuffix + ext);
  }
});

// 配置 multer
const upload = multer({
  storage: storage,
  limits: {
    fileSize: parseInt(process.env.MAX_FILE_SIZE) || 5 * 1024 * 1024, // 5MB
    files: 5 // 最多5个文件
  },
  fileFilter: fileFilter
});

// 验证中间件
const handleValidation = (req, res, next) => {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({
      error: '请求参数验证失败',
      details: errors.array()
    });
  }
  next();
};

// 单文件上传
router.post('/single', upload.single('file'), (req, res) => {
  try {
    if (!req.file) {
      return res.status(400).json({ error: '未选择文件' });
    }

    const fileUrl = `/uploads/${req.file.mimetype.startsWith('image/') ? 'images' : 'documents'}/${req.file.filename}`;
    
    logger.info(`文件上传成功: ${req.file.originalname} -> ${req.file.filename}`);
    
    res.json({
      message: '文件上传成功',
      data: {
        filename: req.file.filename,
        originalName: req.file.originalname,
        mimetype: req.file.mimetype,
        size: req.file.size,
        url: fileUrl,
        path: req.file.path
      }
    });

  } catch (error) {
    logger.error('单文件上传失败:', error);
    res.status(500).json({ error: '文件上传失败' });
  }
});

// 多文件上传
router.post('/multiple', upload.array('files', 5), (req, res) => {
  try {
    if (!req.files || req.files.length === 0) {
      return res.status(400).json({ error: '未选择文件' });
    }

    const uploadedFiles = req.files.map(file => {
      const fileUrl = `/uploads/${file.mimetype.startsWith('image/') ? 'images' : 'documents'}/${file.filename}`;
      
      return {
        filename: file.filename,
        originalName: file.originalname,
        mimetype: file.mimetype,
        size: file.size,
        url: fileUrl,
        path: file.path
      };
    });
    
    logger.info(`批量文件上传成功: ${req.files.length} 个文件`);
    
    res.json({
      message: '文件批量上传成功',
      data: uploadedFiles,
      count: uploadedFiles.length
    });

  } catch (error) {
    logger.error('批量文件上传失败:', error);
    res.status(500).json({ error: '文件上传失败' });
  }
});

// 图片上传（专门的图片上传接口）
router.post('/image', upload.single('image'), (req, res) => {
  try {
    if (!req.file) {
      return res.status(400).json({ error: '未选择图片' });
    }

    if (!req.file.mimetype.startsWith('image/')) {
      // 删除已上传的非图片文件
      fs.unlinkSync(req.file.path);
      return res.status(400).json({ error: '请上传图片文件' });
    }

    const imageUrl = `/uploads/images/${req.file.filename}`;
    
    logger.info(`图片上传成功: ${req.file.originalname} -> ${req.file.filename}`);
    
    res.json({
      message: '图片上传成功',
      data: {
        filename: req.file.filename,
        originalName: req.file.originalname,
        mimetype: req.file.mimetype,
        size: req.file.size,
        url: imageUrl,
        width: null, // 可以使用 sharp 库获取图片尺寸
        height: null
      }
    });

  } catch (error) {
    logger.error('图片上传失败:', error);
    res.status(500).json({ error: '图片上传失败' });
  }
});

// 删除文件
router.delete('/:type/:filename', (req, res) => {
  try {
    const { type, filename } = req.params;
    
    if (!['images', 'documents'].includes(type)) {
      return res.status(400).json({ error: '文件类型无效' });
    }
    
    const filePath = path.join(uploadDir, type, filename);
    
    // 安全检查：确保文件路径在允许的目录内
    const resolvedPath = path.resolve(filePath);
    const allowedDir = path.resolve(path.join(uploadDir, type));
    
    if (!resolvedPath.startsWith(allowedDir)) {
      return res.status(403).json({ error: '非法文件路径' });
    }

    // 检查文件是否存在
    if (!fs.existsSync(filePath)) {
      return res.status(404).json({ error: '文件不存在' });
    }

    // 删除文件
    fs.unlinkSync(filePath);
    
    logger.info(`文件删除成功: ${filename}`);
    
    res.json({ message: '文件删除成功' });

  } catch (error) {
    logger.error('文件删除失败:', error);
    res.status(500).json({ error: '文件删除失败' });
  }
});

// 获取文件信息
router.get('/info/:type/:filename', (req, res) => {
  try {
    const { type, filename } = req.params;
    
    if (!['images', 'documents'].includes(type)) {
      return res.status(400).json({ error: '文件类型无效' });
    }
    
    const filePath = path.join(uploadDir, type, filename);
    
    // 安全检查
    const resolvedPath = path.resolve(filePath);
    const allowedDir = path.resolve(path.join(uploadDir, type));
    
    if (!resolvedPath.startsWith(allowedDir)) {
      return res.status(403).json({ error: '非法文件路径' });
    }

    // 检查文件是否存在
    if (!fs.existsSync(filePath)) {
      return res.status(404).json({ error: '文件不存在' });
    }

    // 获取文件信息
    const stats = fs.statSync(filePath);
    const ext = path.extname(filename);
    
    res.json({
      data: {
        filename: filename,
        size: stats.size,
        extension: ext,
        created: stats.birthtime,
        modified: stats.mtime,
        url: `/uploads/${type}/${filename}`,
        type: type
      }
    });

  } catch (error) {
    logger.error('获取文件信息失败:', error);
    res.status(500).json({ error: '获取文件信息失败' });
  }
});

// 获取上传目录文件列表
router.get('/list/:type', (req, res) => {
  try {
    const { type } = req.params;
    
    if (!['images', 'documents'].includes(type)) {
      return res.status(400).json({ error: '文件类型无效' });
    }
    
    const dirPath = path.join(uploadDir, type);
    
    if (!fs.existsSync(dirPath)) {
      return res.json({ data: [], count: 0 });
    }
    
    const files = fs.readdirSync(dirPath)
      .filter(file => fs.statSync(path.join(dirPath, file)).isFile())
      .map(filename => {
        const filePath = path.join(dirPath, filename);
        const stats = fs.statSync(filePath);
        
        return {
          filename: filename,
          size: stats.size,
          created: stats.birthtime,
          modified: stats.mtime,
          url: `/uploads/${type}/${filename}`,
          type: type
        };
      })
      .sort((a, b) => new Date(b.created) - new Date(a.created)); // 按创建时间倒序
    
    res.json({
      data: files,
      count: files.length
    });

  } catch (error) {
    logger.error('获取文件列表失败:', error);
    res.status(500).json({ error: '获取文件列表失败' });
  }
});

// 错误处理中间件
router.use((error, req, res, next) => {
  if (error instanceof multer.MulterError) {
    if (error.code === 'LIMIT_FILE_SIZE') {
      return res.status(400).json({ error: '文件大小超出限制' });
    }
    if (error.code === 'LIMIT_FILE_COUNT') {
      return res.status(400).json({ error: '文件数量超出限制' });
    }
    if (error.code === 'LIMIT_UNEXPECTED_FILE') {
      return res.status(400).json({ error: '意外的文件字段' });
    }
  }
  
  if (error.message === '不支持的文件类型') {
    return res.status(400).json({ error: '不支持的文件类型' });
  }
  
  logger.error('文件上传错误:', error);
  res.status(500).json({ error: '文件处理失败' });
});

module.exports = router; 